home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Bank smakow / BankSmakow.air / BankSmakow.swf / scripts / mx / managers / ToolTipManagerImpl.as < prev    next >
Text File  |  2009-12-16  |  24KB  |  746 lines
  1. package mx.managers
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.events.Event;
  5.    import flash.events.EventDispatcher;
  6.    import flash.events.IEventDispatcher;
  7.    import flash.events.MouseEvent;
  8.    import flash.events.TimerEvent;
  9.    import flash.geom.Point;
  10.    import flash.geom.Rectangle;
  11.    import flash.utils.Timer;
  12.    import mx.controls.ToolTip;
  13.    import mx.core.ApplicationGlobals;
  14.    import mx.core.IInvalidating;
  15.    import mx.core.IToolTip;
  16.    import mx.core.IUIComponent;
  17.    import mx.core.mx_internal;
  18.    import mx.effects.EffectManager;
  19.    import mx.effects.IAbstractEffect;
  20.    import mx.events.EffectEvent;
  21.    import mx.events.InterManagerRequest;
  22.    import mx.events.ToolTipEvent;
  23.    import mx.styles.IStyleClient;
  24.    import mx.validators.IValidatorListener;
  25.    
  26.    use namespace mx_internal;
  27.    
  28.    public class ToolTipManagerImpl extends EventDispatcher implements IToolTipManager2
  29.    {
  30.       
  31.       mx_internal static const VERSION:String = "3.5.0.12683";
  32.       
  33.       private static var instance:IToolTipManager2;
  34.        
  35.       
  36.       private var _enabled:Boolean = true;
  37.       
  38.       private var _showDelay:Number = 500;
  39.       
  40.       private var _hideEffect:IAbstractEffect;
  41.       
  42.       mx_internal var hideTimer:Timer;
  43.       
  44.       private var _scrubDelay:Number = 100;
  45.       
  46.       private var _toolTipClass:Class;
  47.       
  48.       mx_internal var showTimer:Timer;
  49.       
  50.       private var sandboxRoot:IEventDispatcher = null;
  51.       
  52.       mx_internal var currentText:String;
  53.       
  54.       private var _currentToolTip:DisplayObject;
  55.       
  56.       mx_internal var scrubTimer:Timer;
  57.       
  58.       mx_internal var previousTarget:DisplayObject;
  59.       
  60.       private var _currentTarget:DisplayObject;
  61.       
  62.       private var systemManager:ISystemManager = null;
  63.       
  64.       private var _showEffect:IAbstractEffect;
  65.       
  66.       private var _hideDelay:Number = 10000;
  67.       
  68.       mx_internal var initialized:Boolean = false;
  69.       
  70.       mx_internal var isError:Boolean;
  71.       
  72.       public function ToolTipManagerImpl()
  73.       {
  74.          _toolTipClass = ToolTip;
  75.          super();
  76.          if(instance)
  77.          {
  78.             throw new Error("Instance already exists.");
  79.          }
  80.          this.systemManager = SystemManagerGlobals.topLevelSystemManagers[0] as ISystemManager;
  81.          sandboxRoot = this.systemManager.getSandboxRoot();
  82.          sandboxRoot.addEventListener(InterManagerRequest.TOOLTIP_MANAGER_REQUEST,marshalToolTipManagerHandler,false,0,true);
  83.          var _loc1_:InterManagerRequest = new InterManagerRequest(InterManagerRequest.TOOLTIP_MANAGER_REQUEST);
  84.          _loc1_.name = "update";
  85.          sandboxRoot.dispatchEvent(_loc1_);
  86.       }
  87.       
  88.       public static function getInstance() : IToolTipManager2
  89.       {
  90.          if(!instance)
  91.          {
  92.             instance = new ToolTipManagerImpl();
  93.          }
  94.          return instance;
  95.       }
  96.       
  97.       mx_internal function systemManager_mouseDownHandler(param1:MouseEvent) : void
  98.       {
  99.          reset();
  100.       }
  101.       
  102.       public function set showDelay(param1:Number) : void
  103.       {
  104.          _showDelay = param1;
  105.       }
  106.       
  107.       mx_internal function showTimer_timerHandler(param1:TimerEvent) : void
  108.       {
  109.          if(currentTarget)
  110.          {
  111.             createTip();
  112.             initializeTip();
  113.             positionTip();
  114.             showTip();
  115.          }
  116.       }
  117.       
  118.       mx_internal function hideEffectEnded() : void
  119.       {
  120.          var _loc1_:ToolTipEvent = null;
  121.          reset();
  122.          if(mx_internal::previousTarget)
  123.          {
  124.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_END);
  125.             _loc1_.toolTip = currentToolTip;
  126.             mx_internal::previousTarget.dispatchEvent(_loc1_);
  127.          }
  128.       }
  129.       
  130.       public function set scrubDelay(param1:Number) : void
  131.       {
  132.          _scrubDelay = param1;
  133.       }
  134.       
  135.       public function get currentToolTip() : IToolTip
  136.       {
  137.          return _currentToolTip as IToolTip;
  138.       }
  139.       
  140.       private function mouseIsOver(param1:DisplayObject) : Boolean
  141.       {
  142.          if(!param1 || !param1.stage)
  143.          {
  144.             return false;
  145.          }
  146.          if(param1.stage.mouseX == 0 && param1.stage.mouseY == 0)
  147.          {
  148.             return false;
  149.          }
  150.          return param1.hitTestPoint(param1.stage.mouseX,param1.stage.mouseY,true);
  151.       }
  152.       
  153.       mx_internal function toolTipMouseOutHandler(param1:MouseEvent) : void
  154.       {
  155.          checkIfTargetChanged(param1.relatedObject);
  156.       }
  157.       
  158.       public function get enabled() : Boolean
  159.       {
  160.          return _enabled;
  161.       }
  162.       
  163.       public function createToolTip(param1:String, param2:Number, param3:Number, param4:String = null, param5:IUIComponent = null) : IToolTip
  164.       {
  165.          var _loc6_:ToolTip = new ToolTip();
  166.          var _loc7_:ISystemManager;
  167.          (_loc7_ = !!param5 ? param5.systemManager as ISystemManager : ApplicationGlobals.application.systemManager as ISystemManager).topLevelSystemManager.addChildToSandboxRoot("toolTipChildren",_loc6_ as DisplayObject);
  168.          if(param4)
  169.          {
  170.             _loc6_.setStyle("styleName","errorTip");
  171.             _loc6_.setStyle("borderStyle",param4);
  172.          }
  173.          _loc6_.text = param1;
  174.          sizeTip(_loc6_);
  175.          _loc6_.move(param2,param3);
  176.          return _loc6_ as IToolTip;
  177.       }
  178.       
  179.       mx_internal function reset() : void
  180.       {
  181.          var _loc1_:ISystemManager = null;
  182.          mx_internal::showTimer.reset();
  183.          mx_internal::hideTimer.reset();
  184.          if(currentToolTip)
  185.          {
  186.             if(showEffect || hideEffect)
  187.             {
  188.                currentToolTip.removeEventListener(EffectEvent.EFFECT_END,mx_internal::effectEndHandler);
  189.             }
  190.             EffectManager.endEffectsForTarget(currentToolTip);
  191.             _loc1_ = currentToolTip.systemManager as ISystemManager;
  192.             _loc1_.topLevelSystemManager.removeChildFromSandboxRoot("toolTipChildren",currentToolTip as DisplayObject);
  193.             currentToolTip = null;
  194.             mx_internal::scrubTimer.delay = scrubDelay;
  195.             mx_internal::scrubTimer.reset();
  196.             if(scrubDelay > 0)
  197.             {
  198.                mx_internal::scrubTimer.delay = scrubDelay;
  199.                mx_internal::scrubTimer.start();
  200.             }
  201.          }
  202.       }
  203.       
  204.       public function set currentToolTip(param1:IToolTip) : void
  205.       {
  206.          _currentToolTip = param1 as DisplayObject;
  207.          var _loc2_:InterManagerRequest = new InterManagerRequest(InterManagerRequest.TOOLTIP_MANAGER_REQUEST);
  208.          _loc2_.name = "currentToolTip";
  209.          _loc2_.value = param1;
  210.          sandboxRoot.dispatchEvent(_loc2_);
  211.       }
  212.       
  213.       public function get toolTipClass() : Class
  214.       {
  215.          return _toolTipClass;
  216.       }
  217.       
  218.       private function hideImmediately(param1:DisplayObject) : void
  219.       {
  220.          checkIfTargetChanged(null);
  221.       }
  222.       
  223.       mx_internal function showTip() : void
  224.       {
  225.          var _loc2_:ISystemManager = null;
  226.          var _loc1_:ToolTipEvent = new ToolTipEvent(ToolTipEvent.TOOL_TIP_SHOW);
  227.          _loc1_.toolTip = currentToolTip;
  228.          currentTarget.dispatchEvent(_loc1_);
  229.          if(mx_internal::isError)
  230.          {
  231.             currentTarget.addEventListener("change",mx_internal::changeHandler);
  232.          }
  233.          else
  234.          {
  235.             _loc2_ = getSystemManager(currentTarget);
  236.             _loc2_.addEventListener(MouseEvent.MOUSE_DOWN,mx_internal::systemManager_mouseDownHandler);
  237.          }
  238.          currentToolTip.visible = true;
  239.          if(!showEffect)
  240.          {
  241.             showEffectEnded();
  242.          }
  243.       }
  244.       
  245.       mx_internal function effectEndHandler(param1:EffectEvent) : void
  246.       {
  247.          if(param1.effectInstance.effect == showEffect)
  248.          {
  249.             showEffectEnded();
  250.          }
  251.          else if(param1.effectInstance.effect == hideEffect)
  252.          {
  253.             hideEffectEnded();
  254.          }
  255.       }
  256.       
  257.       public function get hideDelay() : Number
  258.       {
  259.          return _hideDelay;
  260.       }
  261.       
  262.       public function get currentTarget() : DisplayObject
  263.       {
  264.          return _currentTarget;
  265.       }
  266.       
  267.       mx_internal function showEffectEnded() : void
  268.       {
  269.          var _loc1_:ToolTipEvent = null;
  270.          if(hideDelay == 0)
  271.          {
  272.             hideTip();
  273.          }
  274.          else if(hideDelay < Infinity)
  275.          {
  276.             mx_internal::hideTimer.delay = hideDelay;
  277.             mx_internal::hideTimer.start();
  278.          }
  279.          if(currentTarget)
  280.          {
  281.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_SHOWN);
  282.             _loc1_.toolTip = currentToolTip;
  283.             currentTarget.dispatchEvent(_loc1_);
  284.          }
  285.       }
  286.       
  287.       public function get hideEffect() : IAbstractEffect
  288.       {
  289.          return _hideEffect;
  290.       }
  291.       
  292.       mx_internal function changeHandler(param1:Event) : void
  293.       {
  294.          reset();
  295.       }
  296.       
  297.       public function set enabled(param1:Boolean) : void
  298.       {
  299.          _enabled = param1;
  300.       }
  301.       
  302.       mx_internal function errorTipMouseOverHandler(param1:MouseEvent) : void
  303.       {
  304.          checkIfTargetChanged(DisplayObject(param1.target));
  305.       }
  306.       
  307.       public function get showDelay() : Number
  308.       {
  309.          return _showDelay;
  310.       }
  311.       
  312.       public function get scrubDelay() : Number
  313.       {
  314.          return _scrubDelay;
  315.       }
  316.       
  317.       public function registerErrorString(param1:DisplayObject, param2:String, param3:String) : void
  318.       {
  319.          if(!param2 && param3)
  320.          {
  321.             param1.addEventListener(MouseEvent.MOUSE_OVER,mx_internal::errorTipMouseOverHandler);
  322.             param1.addEventListener(MouseEvent.MOUSE_OUT,mx_internal::errorTipMouseOutHandler);
  323.             if(mouseIsOver(param1))
  324.             {
  325.                showImmediately(param1);
  326.             }
  327.          }
  328.          else if(param2 && !param3)
  329.          {
  330.             param1.removeEventListener(MouseEvent.MOUSE_OVER,mx_internal::errorTipMouseOverHandler);
  331.             param1.removeEventListener(MouseEvent.MOUSE_OUT,mx_internal::errorTipMouseOutHandler);
  332.             if(mouseIsOver(param1))
  333.             {
  334.                hideImmediately(param1);
  335.             }
  336.          }
  337.       }
  338.       
  339.       mx_internal function initialize() : void
  340.       {
  341.          if(!mx_internal::showTimer)
  342.          {
  343.             showTimer = new Timer(0,1);
  344.             mx_internal::showTimer.addEventListener(TimerEvent.TIMER,mx_internal::showTimer_timerHandler);
  345.          }
  346.          if(!mx_internal::hideTimer)
  347.          {
  348.             hideTimer = new Timer(0,1);
  349.             mx_internal::hideTimer.addEventListener(TimerEvent.TIMER,mx_internal::hideTimer_timerHandler);
  350.          }
  351.          if(!mx_internal::scrubTimer)
  352.          {
  353.             scrubTimer = new Timer(0,1);
  354.          }
  355.          initialized = true;
  356.       }
  357.       
  358.       public function destroyToolTip(param1:IToolTip) : void
  359.       {
  360.          var _loc2_:ISystemManager = param1.systemManager as ISystemManager;
  361.          _loc2_.topLevelSystemManager.removeChildFromSandboxRoot("toolTipChildren",DisplayObject(param1));
  362.       }
  363.       
  364.       mx_internal function checkIfTargetChanged(param1:DisplayObject) : void
  365.       {
  366.          if(!enabled)
  367.          {
  368.             return;
  369.          }
  370.          findTarget(param1);
  371.          if(currentTarget != mx_internal::previousTarget)
  372.          {
  373.             targetChanged();
  374.             previousTarget = currentTarget;
  375.          }
  376.       }
  377.       
  378.       private function marshalToolTipManagerHandler(param1:Event) : void
  379.       {
  380.          var _loc2_:InterManagerRequest = null;
  381.          if(param1 is InterManagerRequest)
  382.          {
  383.             return;
  384.          }
  385.          var _loc3_:Object = param1;
  386.          switch(_loc3_.name)
  387.          {
  388.             case "currentToolTip":
  389.                _currentToolTip = _loc3_.value;
  390.                break;
  391.             case ToolTipEvent.TOOL_TIP_HIDE:
  392.                if(_currentToolTip is IToolTip)
  393.                {
  394.                   hideTip();
  395.                }
  396.                break;
  397.             case "update":
  398.                param1.stopImmediatePropagation();
  399.                _loc2_ = new InterManagerRequest(InterManagerRequest.TOOLTIP_MANAGER_REQUEST);
  400.                _loc2_.name = "currentToolTip";
  401.                _loc2_.value = _currentToolTip;
  402.                sandboxRoot.dispatchEvent(_loc2_);
  403.          }
  404.       }
  405.       
  406.       public function set toolTipClass(param1:Class) : void
  407.       {
  408.          _toolTipClass = param1;
  409.       }
  410.       
  411.       private function getGlobalBounds(param1:DisplayObject, param2:DisplayObject) : Rectangle
  412.       {
  413.          var _loc3_:Point = new Point(0,0);
  414.          _loc3_ = param1.localToGlobal(_loc3_);
  415.          _loc3_ = param2.globalToLocal(_loc3_);
  416.          return new Rectangle(_loc3_.x,_loc3_.y,param1.width,param1.height);
  417.       }
  418.       
  419.       mx_internal function positionTip() : void
  420.       {
  421.          var _loc1_:Number = NaN;
  422.          var _loc2_:Number = NaN;
  423.          var _loc5_:Rectangle = null;
  424.          var _loc6_:Number = NaN;
  425.          var _loc7_:Number = NaN;
  426.          var _loc8_:ISystemManager = null;
  427.          var _loc9_:Number = NaN;
  428.          var _loc10_:Number = NaN;
  429.          var _loc11_:Point = null;
  430.          var _loc3_:Number = currentToolTip.screen.width;
  431.          var _loc4_:Number = currentToolTip.screen.height;
  432.          if(mx_internal::isError)
  433.          {
  434.             _loc1_ = (_loc5_ = getGlobalBounds(currentTarget,currentToolTip.root)).right + 4;
  435.             _loc2_ = _loc5_.top - 1;
  436.             if(_loc1_ + currentToolTip.width > _loc3_)
  437.             {
  438.                _loc6_ = NaN;
  439.                _loc7_ = NaN;
  440.                _loc1_ = _loc5_.left - 2;
  441.                if(_loc1_ + currentToolTip.width + 4 > _loc3_)
  442.                {
  443.                   _loc6_ = _loc3_ - _loc1_ - 4;
  444.                   _loc7_ = Object(toolTipClass).maxWidth;
  445.                   Object(toolTipClass).maxWidth = _loc6_;
  446.                   if(currentToolTip is IStyleClient)
  447.                   {
  448.                      IStyleClient(currentToolTip).setStyle("borderStyle","errorTipAbove");
  449.                   }
  450.                   currentToolTip["text"] = currentToolTip["text"];
  451.                }
  452.                else
  453.                {
  454.                   if(currentToolTip is IStyleClient)
  455.                   {
  456.                      IStyleClient(currentToolTip).setStyle("borderStyle","errorTipAbove");
  457.                   }
  458.                   currentToolTip["text"] = currentToolTip["text"];
  459.                }
  460.                if(currentToolTip.height + 2 < _loc5_.top)
  461.                {
  462.                   _loc2_ = _loc5_.top - (currentToolTip.height + 2);
  463.                }
  464.                else
  465.                {
  466.                   _loc2_ = _loc5_.bottom + 2;
  467.                   if(!isNaN(_loc6_))
  468.                   {
  469.                      Object(toolTipClass).maxWidth = _loc6_;
  470.                   }
  471.                   if(currentToolTip is IStyleClient)
  472.                   {
  473.                      IStyleClient(currentToolTip).setStyle("borderStyle","errorTipBelow");
  474.                   }
  475.                   currentToolTip["text"] = currentToolTip["text"];
  476.                }
  477.             }
  478.             sizeTip(currentToolTip);
  479.             if(!isNaN(_loc7_))
  480.             {
  481.                Object(toolTipClass).maxWidth = _loc7_;
  482.             }
  483.          }
  484.          else
  485.          {
  486.             _loc8_ = getSystemManager(currentTarget);
  487.             _loc1_ = DisplayObject(_loc8_).mouseX + 11;
  488.             _loc2_ = DisplayObject(_loc8_).mouseY + 22;
  489.             _loc9_ = currentToolTip.width;
  490.             if(_loc1_ + _loc9_ > _loc3_)
  491.             {
  492.                _loc1_ = _loc3_ - _loc9_;
  493.             }
  494.             _loc10_ = currentToolTip.height;
  495.             if(_loc2_ + _loc10_ > _loc4_)
  496.             {
  497.                _loc2_ = _loc4_ - _loc10_;
  498.             }
  499.             _loc11_ = new Point(_loc1_,_loc2_);
  500.             _loc11_ = DisplayObject(_loc8_).localToGlobal(_loc11_);
  501.             _loc1_ = (_loc11_ = DisplayObject(sandboxRoot).globalToLocal(_loc11_)).x;
  502.             _loc2_ = _loc11_.y;
  503.          }
  504.          currentToolTip.move(_loc1_,_loc2_);
  505.       }
  506.       
  507.       mx_internal function errorTipMouseOutHandler(param1:MouseEvent) : void
  508.       {
  509.          checkIfTargetChanged(param1.relatedObject);
  510.       }
  511.       
  512.       mx_internal function findTarget(param1:DisplayObject) : void
  513.       {
  514.          while(param1)
  515.          {
  516.             if(param1 is IValidatorListener)
  517.             {
  518.                currentText = IValidatorListener(param1).errorString;
  519.                if(mx_internal::currentText != null && mx_internal::currentText != "")
  520.                {
  521.                   currentTarget = param1;
  522.                   isError = true;
  523.                   return;
  524.                }
  525.             }
  526.             if(param1 is IToolTipManagerClient)
  527.             {
  528.                currentText = IToolTipManagerClient(param1).toolTip;
  529.                if(mx_internal::currentText != null)
  530.                {
  531.                   currentTarget = param1;
  532.                   isError = false;
  533.                   return;
  534.                }
  535.             }
  536.             param1 = param1.parent;
  537.          }
  538.          currentText = null;
  539.          currentTarget = null;
  540.       }
  541.       
  542.       public function registerToolTip(param1:DisplayObject, param2:String, param3:String) : void
  543.       {
  544.          if(!param2 && param3)
  545.          {
  546.             param1.addEventListener(MouseEvent.MOUSE_OVER,mx_internal::toolTipMouseOverHandler);
  547.             param1.addEventListener(MouseEvent.MOUSE_OUT,mx_internal::toolTipMouseOutHandler);
  548.             if(mouseIsOver(param1))
  549.             {
  550.                showImmediately(param1);
  551.             }
  552.          }
  553.          else if(param2 && !param3)
  554.          {
  555.             param1.removeEventListener(MouseEvent.MOUSE_OVER,mx_internal::toolTipMouseOverHandler);
  556.             param1.removeEventListener(MouseEvent.MOUSE_OUT,mx_internal::toolTipMouseOutHandler);
  557.             if(mouseIsOver(param1))
  558.             {
  559.                hideImmediately(param1);
  560.             }
  561.          }
  562.       }
  563.       
  564.       private function showImmediately(param1:DisplayObject) : void
  565.       {
  566.          var _loc2_:Number = ToolTipManager.showDelay;
  567.          ToolTipManager.showDelay = 0;
  568.          checkIfTargetChanged(param1);
  569.          ToolTipManager.showDelay = _loc2_;
  570.       }
  571.       
  572.       public function set hideDelay(param1:Number) : void
  573.       {
  574.          _hideDelay = param1;
  575.       }
  576.       
  577.       private function getSystemManager(param1:DisplayObject) : ISystemManager
  578.       {
  579.          return param1 is IUIComponent ? IUIComponent(param1).systemManager : null;
  580.       }
  581.       
  582.       public function set currentTarget(param1:DisplayObject) : void
  583.       {
  584.          _currentTarget = param1;
  585.       }
  586.       
  587.       public function sizeTip(param1:IToolTip) : void
  588.       {
  589.          if(param1 is IInvalidating)
  590.          {
  591.             IInvalidating(param1).validateNow();
  592.          }
  593.          param1.setActualSize(param1.getExplicitOrMeasuredWidth(),param1.getExplicitOrMeasuredHeight());
  594.       }
  595.       
  596.       public function set showEffect(param1:IAbstractEffect) : void
  597.       {
  598.          _showEffect = param1 as IAbstractEffect;
  599.       }
  600.       
  601.       mx_internal function targetChanged() : void
  602.       {
  603.          var _loc1_:ToolTipEvent = null;
  604.          var _loc2_:InterManagerRequest = null;
  605.          if(!mx_internal::initialized)
  606.          {
  607.             initialize();
  608.          }
  609.          if(mx_internal::previousTarget && currentToolTip)
  610.          {
  611.             if(currentToolTip is IToolTip)
  612.             {
  613.                _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_HIDE);
  614.                _loc1_.toolTip = currentToolTip;
  615.                mx_internal::previousTarget.dispatchEvent(_loc1_);
  616.             }
  617.             else
  618.             {
  619.                _loc2_ = new InterManagerRequest(InterManagerRequest.TOOLTIP_MANAGER_REQUEST);
  620.                _loc2_.name = ToolTipEvent.TOOL_TIP_HIDE;
  621.                sandboxRoot.dispatchEvent(_loc2_);
  622.             }
  623.          }
  624.          reset();
  625.          if(currentTarget)
  626.          {
  627.             if(mx_internal::currentText == "")
  628.             {
  629.                return;
  630.             }
  631.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_START);
  632.             currentTarget.dispatchEvent(_loc1_);
  633.             if(showDelay == 0 || mx_internal::scrubTimer.running)
  634.             {
  635.                createTip();
  636.                initializeTip();
  637.                positionTip();
  638.                showTip();
  639.             }
  640.             else
  641.             {
  642.                mx_internal::showTimer.delay = showDelay;
  643.                mx_internal::showTimer.start();
  644.             }
  645.          }
  646.       }
  647.       
  648.       public function set hideEffect(param1:IAbstractEffect) : void
  649.       {
  650.          _hideEffect = param1 as IAbstractEffect;
  651.       }
  652.       
  653.       mx_internal function hideTimer_timerHandler(param1:TimerEvent) : void
  654.       {
  655.          hideTip();
  656.       }
  657.       
  658.       mx_internal function initializeTip() : void
  659.       {
  660.          if(currentToolTip is IToolTip)
  661.          {
  662.             IToolTip(currentToolTip).text = mx_internal::currentText;
  663.          }
  664.          if(mx_internal::isError && currentToolTip is IStyleClient)
  665.          {
  666.             IStyleClient(currentToolTip).setStyle("styleName","errorTip");
  667.          }
  668.          sizeTip(currentToolTip);
  669.          if(currentToolTip is IStyleClient)
  670.          {
  671.             if(showEffect)
  672.             {
  673.                IStyleClient(currentToolTip).setStyle("showEffect",showEffect);
  674.             }
  675.             if(hideEffect)
  676.             {
  677.                IStyleClient(currentToolTip).setStyle("hideEffect",hideEffect);
  678.             }
  679.          }
  680.          if(showEffect || hideEffect)
  681.          {
  682.             currentToolTip.addEventListener(EffectEvent.EFFECT_END,mx_internal::effectEndHandler);
  683.          }
  684.       }
  685.       
  686.       public function get showEffect() : IAbstractEffect
  687.       {
  688.          return _showEffect;
  689.       }
  690.       
  691.       mx_internal function toolTipMouseOverHandler(param1:MouseEvent) : void
  692.       {
  693.          checkIfTargetChanged(DisplayObject(param1.target));
  694.       }
  695.       
  696.       mx_internal function hideTip() : void
  697.       {
  698.          var _loc1_:ToolTipEvent = null;
  699.          var _loc2_:ISystemManager = null;
  700.          if(mx_internal::previousTarget)
  701.          {
  702.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_HIDE);
  703.             _loc1_.toolTip = currentToolTip;
  704.             mx_internal::previousTarget.dispatchEvent(_loc1_);
  705.          }
  706.          if(currentToolTip)
  707.          {
  708.             currentToolTip.visible = false;
  709.          }
  710.          if(mx_internal::isError)
  711.          {
  712.             if(currentTarget)
  713.             {
  714.                currentTarget.removeEventListener("change",mx_internal::changeHandler);
  715.             }
  716.          }
  717.          else if(mx_internal::previousTarget)
  718.          {
  719.             _loc2_ = getSystemManager(mx_internal::previousTarget);
  720.             _loc2_.removeEventListener(MouseEvent.MOUSE_DOWN,mx_internal::systemManager_mouseDownHandler);
  721.          }
  722.          if(!hideEffect)
  723.          {
  724.             hideEffectEnded();
  725.          }
  726.       }
  727.       
  728.       mx_internal function createTip() : void
  729.       {
  730.          var _loc1_:ToolTipEvent = new ToolTipEvent(ToolTipEvent.TOOL_TIP_CREATE);
  731.          currentTarget.dispatchEvent(_loc1_);
  732.          if(_loc1_.toolTip)
  733.          {
  734.             currentToolTip = _loc1_.toolTip;
  735.          }
  736.          else
  737.          {
  738.             currentToolTip = new toolTipClass();
  739.          }
  740.          currentToolTip.visible = false;
  741.          var _loc2_:ISystemManager = getSystemManager(currentTarget) as ISystemManager;
  742.          _loc2_.topLevelSystemManager.addChildToSandboxRoot("toolTipChildren",currentToolTip as DisplayObject);
  743.       }
  744.    }
  745. }
  746.